home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / C / ESPRESSO.ZIP / CVRMISC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-03-14  |  4.6 KB  |  184 lines
  1. #include "espresso.h"
  2.  
  3. /* fatal -- report fatal error message and take a dive */
  4. void fatal(s)
  5. char *s;
  6. {
  7.     fprintf(stderr, "%s\n", s);
  8.     exit(-1);
  9. }
  10.  
  11. /* cost -- compute the cost of a cover */
  12. void cover_cost(F, cost)
  13. pcover F;
  14. pcost cost;
  15. {
  16.     register pcube m, p, last, temp = cube.temp[0], temp1 = cube.temp[1];
  17.  
  18.     cost->cubes = F->count;
  19.  
  20.     /* #in is number of transistors in binary variables */
  21.     m = cube.binary_mask;
  22.     cost->in = 0;
  23.     foreach_set(F, last, p)
  24.         cost->in += set_ord(set_diff(temp, m, p));
  25.  
  26.     /* #out is number of transistors everywhere else */
  27.     m = set_diff(temp1, cube.fullset, m);
  28.     cost->out = 0;
  29.     foreach_set(F, last, p)
  30.         cost->out += set_ord(set_and(temp, m, p));
  31.  
  32.     cost->primes = 0;
  33.     foreach_set(F, last, p)
  34.         cost->primes += TESTP(p, PRIME) != 0;
  35. }
  36.  
  37.  
  38. /* print_cost -- return a string which reports the "cost" of a cover */
  39. char *print_cost(F)
  40. pcover F;
  41. {
  42.     static char s[200];
  43.     cost_t cost;
  44.     cover_cost(F, &cost);
  45.     (void) sprintf(s, "c=%d(%d) in=%d out=%d tot=%d",
  46.         cost.cubes, cost.cubes - cost.primes, cost.in, cost.out,
  47.         cost.in + cost.out);
  48.     return s;
  49. }
  50.  
  51. /* copy_cost -- copy a cost function from s to d */
  52. void copy_cost(s, d)
  53. pcost s, d;
  54. {
  55.     d->cubes = s->cubes;
  56.     d->in = s->in;
  57.     d->out = s->out;
  58.     d->primes = s->primes;
  59. }
  60.  
  61. /* cost_better -- compare two cost functions for improvement */
  62. bool cost_better(old, new)
  63. pcost old, new;
  64. {
  65.     if (new->cubes < old->cubes) return TRUE;
  66.     else if (new->cubes > old->cubes) return FALSE;
  67.     else if (new->in+new->out != old->in+old->out) return TRUE;
  68.     else return FALSE;
  69. }
  70.  
  71. /* size_stamp -- print single line giving the size of a cover */
  72. void size_stamp(T, name)
  73. IN pcover T;
  74. IN char *name;
  75. {
  76.     printf("# %s\tCost is %s\n", name, print_cost(T));
  77.     (void) fflush(stdout);
  78. }
  79.  
  80. /* print_trace -- print a line reporting size and time after a function */
  81. void print_trace(T, name, time)
  82. IN pcover T;
  83. IN char *name;
  84. IN double time;
  85. {
  86.     printf("# %s\tTime was %s, cost is %s\n", 
  87.         name, print_time(time), print_cost(T));
  88.     (void) fflush(stdout);
  89. }
  90.  
  91. /* totals -- add time spent in the function into the totals */
  92. void totals(time, index, T, cost)
  93. IN double time;
  94. IN int index;
  95. IN pcover T;
  96. OUT pcost cost;
  97. {
  98.     time = ptime() - time;
  99.     total_time[index] += time;
  100.     total_calls[index]++;
  101.     cover_cost(T, cost);
  102.     if (trace) 
  103.         printf("# %s\tTime was %s, cost is c=%d(%d) in=%d out=%d tot=%d\n",
  104.             total_name[index], print_time(time), cost->cubes, cost->cubes
  105.             -cost->primes, cost->in, cost->out, cost->in+cost->out);
  106.     (void) fflush(stdout);
  107. }
  108.  
  109.  
  110. /* chk_arglist -- check for extra arguments on command line */
  111. void chk_arglist(argc, argv)
  112. int *argc;
  113. char *argv[];
  114. {
  115.     int i;
  116.     if (*argc > 1) {
  117.         fprintf(stderr, "Extraneous arguments ignored:");
  118.         for(i = 1; i < *argc; i++)
  119.             fprintf(stderr, " \"%s\"\n", argv[i]);
  120.     }
  121. }
  122.  
  123.  
  124. /* delete_arg -- delete an argument from the argument list */
  125. void delete_arg(argc, argv, num)
  126. int *argc, num;
  127. register char *argv[];
  128. {
  129.     register int i;
  130.     (*argc)--;
  131.     for(i = num; i < *argc; i++)
  132.         argv[i] = argv[i+1];
  133. }
  134.  
  135.  
  136. /* check_arg -- scan argv for an argument, and return TRUE if found */
  137. bool check_arg(argc, argv, s)
  138. int *argc;
  139. register char *argv[], *s;
  140. {
  141.     register int i;
  142.     for(i = 1; i < *argc; i++)
  143.         if (equal(argv[i], s)) {
  144.             delete_arg(argc, argv, i);
  145.             return TRUE;
  146.         }
  147.     return FALSE;
  148. }
  149.  
  150.  
  151. struct {
  152.     char *key;
  153.     int val;
  154. } debug_flags[] = {
  155.     "-d", EXPAND + ESSEN + IRRED + REDUCE + SPARSE + GASP + SHARP + MINCOV,
  156.     "-compl",   COMPL,  "-essen",       ESSEN,
  157.     "-expand",  EXPAND, "-expand1",     EXPAND1|EXPAND,
  158.     "-gasp",    GASP,   "-irred",       IRRED,
  159.     "-reduce",  REDUCE, "-reduce1",     REDUCE1|REDUCE,
  160.     "-mincov",  MINCOV, "-mincov1",     MINCOV1|MINCOV,
  161.     "-sparse",  SPARSE, "-sharp",       SHARP,
  162.     "-taut",    TAUT,   "-ftaut",       FTAUT,
  163.     0,
  164. };
  165.  
  166. void chk_debug(argc, argv)
  167. int *argc;
  168. char *argv[];
  169. {
  170.     register int i, j;
  171.     debug = 0;
  172.     verbose_debug = FALSE;
  173.     for(i = 1; i < *argc; i++)
  174.         for(j = 0; debug_flags[j].key != 0; j++)
  175.             if (equal(argv[i], debug_flags[j].key)) {
  176.                 delete_arg(argc, argv, i--);
  177.                 debug |= debug_flags[j].val;
  178.                 break;
  179.             } else if (equal(argv[i], "-v")) {
  180.                 verbose_debug = TRUE;
  181.                 delete_arg(argc, argv, i--);
  182.             }
  183. }
  184.